home *** CD-ROM | disk | FTP | other *** search
/ Network Supervisor's Toolkit / Network Supervisor's Toolkit.iso / tools / lu62 / debug / rem_cd.c < prev    next >
C/C++ Source or Header  |  1996-07-10  |  7KB  |  259 lines
  1. /*
  2.  *  CopyRight 1995. Nicholas Poljakov all rights reserved.
  3.  */
  4. /*************************  REM_CD.C  ***************************/
  5. /*                 cd for remote disk                           */
  6. /****************************************************************/
  7.  
  8. #include <dos.h>
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <io.h>
  12. #include <fcntl.h>
  13. #include <stdlib.h>
  14. #include <state1.h>
  15.  
  16.  
  17. extern char lu_id[8];
  18. extern char tp_id[8];
  19. extern char tp_exist;
  20. extern char *pa[2];
  21. extern struct  part {            /* partner structure */
  22.           char     plu[8] ;         /* str plu_name        */
  23.                   int psl;                    /* str plu_s_limit     */
  24.           char     mode_name[8] ;         /* str mode_name        */
  25.                   int max_ru_size;            /* str ru_h_size       */
  26.                   int pacing;                 /* str =               */
  27.                   unsigned char lu_type;
  28.                }  pstr[4];
  29. ExeFl(char *,int);
  30. RemCom(int);
  31.  
  32. rem_cd(e_ptr, from)
  33. int from;
  34. struct f_name {
  35.                 struct f_name *next;
  36.                 struct f_name *prev;
  37.                 char   ind;
  38.                 unsigned int time;
  39.                 unsigned int date;
  40.                 unsigned long int size;
  41.                 char   name[12];
  42.                } *e_ptr;
  43. {
  44.     unsigned  long conv_id;
  45.     unsigned char rts;
  46.     unsigned char wr;
  47.     unsigned int max_length ;
  48.     unsigned  char tpn[64];
  49.     char *p;
  50.     struct rc {
  51.                 unsigned int prim;
  52.                 unsigned long sec;
  53.               } v_rc;
  54.     unsigned long rc;
  55.     char p_lu[9];
  56.     char p_mode[9];
  57.     int length;
  58.     char gds[2];
  59.  
  60.               p = e_ptr -> name;
  61.               if (!tp_exist) {
  62.                                 tp_started
  63.                                             (lu_id,
  64.                                              tp_id,
  65.                                              &rc);
  66.                                 if (rc != 0) {
  67.                                                 return (-1);
  68.                                               }
  69.                                 tp_exist = 1; /* TP_started O.K! */
  70.                              }
  71.  
  72.               strcpy (tpn,"DIR "); /* name of work */
  73.               strcat (tpn, "cd ");      /* name of sub-funct */
  74.               strcat (tpn, p );      /* name of new directory */
  75.               /*conv_id - return param -id work link */
  76.               strcpy(p_lu, pstr[from].plu);
  77.               strcpy(p_mode, pstr[from].mode_name);
  78.                    allocate  (p_lu,
  79.                               p_mode,
  80.                               tpn,
  81.                               WHEN_SESSION_ALLOCATED,
  82.                               NONE,
  83.                               NONE,
  84.                               NULL,
  85.                               NULL,
  86.                               tp_id,
  87.                               &conv_id,
  88.                               NULL,
  89.                               &v_rc) ;
  90.  
  91.  
  92.                   if (v_rc.prim != 0) {
  93.                                           return (-1);
  94.                                        }
  95.               max_length = 2017;
  96.               recwait (tp_id,
  97.                     conv_id,
  98.                     ll,
  99.                     &v_rc,
  100.                     &length,
  101.                     max_length,
  102.                     &rts,
  103.                     &gds,
  104.                     &wr);
  105.                   rem_path(pa[0], from);
  106.        return 0;
  107. }
  108. ExeFl(char *CurFile,int to){
  109.     unsigned  long conv_id;
  110.     unsigned char rts;
  111.     unsigned char wr;
  112.     unsigned int max_length ;
  113.     unsigned  char tpn[64];
  114.     char *p;
  115.     struct rc {
  116.                 unsigned int prim;
  117.                 unsigned long sec;
  118.               } v_rc;
  119.     unsigned long rc;
  120.     char p_lu[9];
  121.     char p_mode[9];
  122.     int length;
  123.     char gds[2];
  124.     char lst[50];
  125.  
  126.     p = &CurFile[strlen(CurFile) - 3];
  127.     if (memcmp(p, "exe", 3) != 0)
  128.          if (memcmp(p , "com", 3) != 0)
  129.               if (memcmp(p , "bat", 3) != 0)
  130.                       return 0;
  131.  
  132.      window(30);
  133.      window_xy(30, 0, 0);
  134.      window_gets(30,lst);
  135.      deactivate(30);
  136.  
  137.  
  138.      if (!tp_exist) {
  139.                        tp_started
  140.                                    (lu_id,
  141.                                     tp_id,
  142.                                     &rc);
  143.                        if (rc != 0) {
  144.                                        return (-1);
  145.                                      }
  146.                        tp_exist = 1; /* TP_started OK! */
  147.                     }
  148.  
  149.      strcpy (tpn,"EXE "); /* name of work */
  150.      strcat (tpn, CurFile); /* name of file */
  151.      strcat (tpn," ");
  152.      strcat (tpn, lst); /* parameter list */
  153.  
  154.      /*conv_id - return param -id work link */
  155.      strcpy(p_lu, pstr[to-1].plu);
  156.      strcpy(p_mode, pstr[to-1].mode_name);
  157.           allocate  (p_lu,
  158.                      p_mode,
  159.                      tpn,
  160.                      WHEN_SESSION_ALLOCATED,
  161.                      NONE,
  162.                      NONE,
  163.                      NULL,
  164.                      NULL,
  165.                      tp_id,
  166.                      &conv_id,
  167.                      NULL,
  168.                      &v_rc) ;
  169.  
  170.  
  171.          if (v_rc.prim != 0) {
  172.                                  return (-1);
  173.                               }
  174.      max_length = 2017;
  175.      recwait (tp_id,
  176.            conv_id,
  177.            ll,
  178.            &v_rc,
  179.            &length,
  180.            max_length,
  181.            &rts,
  182.            &gds,
  183.            &wr);
  184.       return 0;
  185. }
  186.  
  187. RemCom( int to )
  188. {
  189.     unsigned  long conv_id;
  190.     unsigned char rts;
  191.     unsigned char wr;
  192.     unsigned int max_length ;
  193.     unsigned  char tpn[64];
  194.     char *p;
  195.     struct rc {
  196.                 unsigned int prim;
  197.                 unsigned long sec;
  198.               } v_rc;
  199.     unsigned long rc;
  200.     char p_lu[9];
  201.     char p_mode[9];
  202.     int length;
  203.     char gds[2];
  204.     char lst[50];
  205.  
  206.  
  207.      window(30);
  208.      window_xy(30, 0, 0);
  209.      window_gets(30,lst);
  210.      deactivate(30);
  211.  
  212.  
  213.      if (!tp_exist) {
  214.                        tp_started
  215.                                    (lu_id,
  216.                                     tp_id,
  217.                                     &rc);
  218.                        if (rc != 0) {
  219.                                        return (-1);
  220.                                      }
  221.                        tp_exist = 1; /* TP_started OK! */
  222.                     }
  223.  
  224.      strcpy (tpn,"COM "); /* name of work */
  225.      strcat (tpn, lst); /* command */
  226.  
  227.      /*conv_id - return param -id work link */
  228.      strcpy(p_lu, pstr[to-1].plu);
  229.      strcpy(p_mode, pstr[to-1].mode_name);
  230.           allocate  (p_lu,
  231.                      p_mode,
  232.                      tpn,
  233.                      WHEN_SESSION_ALLOCATED,
  234.                      NONE,
  235.                      NONE,
  236.                      NULL,
  237.                      NULL,
  238.                      tp_id,
  239.                      &conv_id,
  240.                      NULL,
  241.                      &v_rc) ;
  242.  
  243.  
  244.          if (v_rc.prim != 0) {
  245.                                  return (-1);
  246.                               }
  247.      max_length = 2017;
  248.      recwait (tp_id,
  249.            conv_id,
  250.            ll,
  251.            &v_rc,
  252.            &length,
  253.            max_length,
  254.            &rts,
  255.            &gds,
  256.            &wr);
  257.       return 0;
  258.  }
  259.